Who am I?

Talk plan

Jumping Rivers

↗ jumpingrivers.com   𝕏 @jumping_uk

• Machine learning
• Dashboard development
• R packages and APIs
• Data pipelines
• Code review

     

My route into Data Science

• PhD in Astrophysics (started 2017)

• Extra training in “Data Intensive Science”

• … academia is hard

• Joined Jumping Rivers full time in 2022 (following an internship)

Life as a “Data Scientist”

My initial experience:

• Software development (check out diffify.com)

• Course writing and teaching

• LOTS of merge requests

• Conferences and meetups

Typical data science workflow

• Data is imported and tidied.
• Cycle of data transformation, visualisation and modelling.
• Results are communicated to an external audience.

From Classical Stats to Machine Learning

MLOps: Machine Learning Operations

• Framework to continuously build, deploy and maintain ML models.
• Encapsulates the “full stack” from data acquisition to model deployment.
• Includes versioning, deployment and monitoring.

Reality for an MLOps beginner

• Countless permutations

  • Modelling frameworks
  • Cloud platforms
  • Environment and container managers

• Very multidisciplinary

• Expensive

MLOps frameworks

• Amazon SageMaker
• Google Cloud Platform
• Kubeflow (ML toolkit for Kubernetes)
• Vetiver by Posit (free to install, nice for beginners)
• And the list goes on…

Vetiver

• Integrates with popular ML libraries in R and Python.
• Fluent tooling to version, deploy and monitor a trained model.
• Deploy to a cloud service or to the localhost.

Data

Palmer Penguin dataset

Data tidying

• Using {tidyr} and {rsample}:

  # Drop missing data
  penguins_data = tidyr::drop_na(penguins)
  
  # Split into train and test sets
  penguins_split = rsample::initial_split(
    penguins_data, prop = 0.8
  )
  train_data = rsample::training(penguins_split)
  test_data = rsample::testing(penguins_split)

Modelling

• Let’s set up the model recipe in {tidymodels}:

library("tidymodels")

model = recipe(
  species ~ island + flipper_length_mm + body_mass_g,
  data = train_data
) |>
  workflow(nearest_neighbor(mode = "classification")) |>
  fit(train_data)

Model testing

• Our model object can now be used to predict species:

model_pred = predict(model, test_data)

# Accuracy for unseen test data
mean(
  model_pred$.pred_class == as.character(
    test_data$species
  )
)

[1] 0.9104478

Enter Vetiver!

• Convert our {tidymodels} model to a {vetiver} model:

  v_model = vetiver::vetiver_model(
    model,
    model_name = "k-nn",
    description = "penguin-species"
  )
  v_model

  
  ── k-nn ─ <bundled_workflow> model for deployment 
  penguin-species using 3 features

• Contains all the info needed to version, store and deploy our model!

Model versioning

• Use {pins} to store R or Python objects for reuse later.

• Store pins using “boards” including Posit Connect, Amazon S3 or even Google drive!

• Storing in a temporary directory:

  model_board = pins::board_temp(
    versioned = TRUE
  )
  model_board |>
    vetiver::vetiver_pin_write(v_model)

Retrieving a model

Model deployment

• We deploy models as APIs which take input data and send back model predictions.

• APIs can be hosted at public endpoints on the web.

• We can run them on the localhost (during testing / development).

• {vetiver} uses {plumber} to create a model API.

Deploying locally

Deploying to Connect

• Vetiver integrates nicely with Posit Connect:

  vetiver::vetiver_deploy_rsconnect(
    board = model_board, "k-nn"
  )

• Easier / quicker if pinned model is on Connect.

• We can also publish to Amazon SageMaker using vetiver_deploy_sagemaker()

Deploying to other cloud platforms

• We start by preparing a Docker container:

  vetiver::vetiver_prepare_docker(
    model_board,
    "k-nn"
  )

• This command:

  • Lists R depedencies with {renv}

  • Stores the {plumber} API code in plumber.R

  • Generates a Dockerfile

Dockerfiles

• Our Dockerfile contains a series of commands to:

  • Install the system libraries (Windows|Mac|Linux).

  • Set the R version and install the required R packages.

  • Run the API in the deployment environment.

Model monitoring

Aside: What about Python?

Modelling tips

• Move from large CSVs to more efficient formats like Parquet and Arrow.
• Version your data or SQL query commands.
• Consider auto-ML tools like H2O.ai and SageMaker Autopilot for selecting models and features .

Deployment

• Try deploying locally to check that your model API works as expected.
• Use environment managers like {renv} to store model dependencies.
• Structuring your code as an R package can help with organising your project dependencies and unit tests.

Cost considerations

Take home lessons

Thanks for listening!

• Slides: bit.ly/2025-lds-mlops
• Vetiver docs: vetiver.posit.co
• Jumping Rivers courses: jumpingrivers.com/training/
• Jumping Rivers blog: jumpingrivers.com/blog/